home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Programming / Emperor_v4.0 / Emperor / Projects / automate_class.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-05  |  3.6 KB  |  157 lines
  1. /*classe cellule*/
  2. class Cellule
  3. {
  4.     private:
  5.  
  6.         int valeur;                 //valeur de la cellule
  7.         BOOL termite;                //si il y a une termitière
  8.         int age_termite;
  9.         int Crayon;                  //rayon d'influence de la termitière
  10.         float pente;                //valeur de la pente
  11.         BOOL influence;              //influence de la termitière sur une cellule éloignée
  12.         float elevation;              //forme de la termitiere
  13.         float altitude;
  14.         //int origine;                //0 pour Idrisi32, 1 pour utilisateur, 2 pour MNA
  15.  
  16.  
  17.     public:
  18.  
  19.         Cellule()                  //constructeur
  20.         {
  21.             valeur=0;
  22.             termite=FALSE;
  23.             age_termite=0;
  24.             Crayon=0;
  25.             pente=0.0;
  26.             influence=FALSE;
  27.             elevation=0.0;
  28.             altitude=200.0;
  29.             //origine=0;
  30.         };
  31.  
  32.         ~Cellule() {};                      //destructeur
  33.  
  34.         void set_valeur(int nvaleur)        //changement de la valeur
  35.         {
  36.             valeur=nvaleur;
  37.         };
  38.  
  39.         void set_termite(BOOL ntermite)               //changement de la termitière
  40.         {
  41.             termite=ntermite;
  42.         };
  43.  
  44.         void set_age_termite(int nage_termite)
  45.         {
  46.             age_termite=nage_termite;
  47.         };
  48.  
  49.         void set_Crayon(int nrayon)          //changement du rayon
  50.         {
  51.             Crayon=nrayon;
  52.         };
  53.  
  54.         void set_pente(float npente)           //changement de la pente
  55.         {
  56.             pente=npente;
  57.         };
  58.  
  59.         void set_influence(BOOL ninfluence)
  60.         {
  61.             influence=ninfluence;
  62.         };
  63.  
  64.         void set_elevation(float nelevation)
  65.         {
  66.             elevation=nelevation;
  67.         };
  68.  
  69.         void set_altitude(int j, int resolution)
  70.         {
  71.             float naltitude=0;
  72.             naltitude=altitude-((pente/resolution)*j)+elevation;
  73.             altitude=naltitude;
  74.         };
  75.  
  76.         void set_altitude(float naltitude)
  77.         {
  78.             /*float naltitude=0;
  79.             naltitude=altitude-((pente/100)*j)+elevation;*/
  80.             altitude=naltitude;
  81.         };
  82.  
  83.         /*void set_origine(int norigine)
  84.         {
  85.             origine=norigine;
  86.         };*/
  87.  
  88.         /*void show_valeur() const         //affichage de la valeur
  89.         {
  90.             cout <<valeur;
  91.         };*/
  92.  
  93.         int retour_valeur() const       //retour de la valeur
  94.         {
  95.             return valeur;
  96.         };
  97.  
  98.         /*int retour_origine() const
  99.         {
  100.             return origine;
  101.         }*/
  102.  
  103.         int retour_age() const
  104.         {
  105.             return age_termite;
  106.         };
  107.  
  108.         float retour_pente() const
  109.         {
  110.             return pente;
  111.         };
  112.  
  113.         float retour_altitude() const
  114.         {
  115.             return altitude;
  116.         };
  117.  
  118.         BOOL retour_termite() const
  119.         {
  120.             return termite;
  121.         };
  122.  
  123.         int retour_Crayon() const
  124.         {
  125.             return Crayon;
  126.         };
  127.  
  128.         BOOL retour_influence() const
  129.         {
  130.             return influence;
  131.         };
  132.  
  133.         float retour_elevation() const
  134.         {
  135.             return elevation;
  136.         };
  137. };
  138. /*fin de classe cellule*/
  139.  
  140. /*modèle de classe*/
  141. template <class T> class Tableau
  142. {
  143.     public:
  144.         Tableau(int i, int j, int k)
  145.             :ptr(new T [i*j*k]), imax(i), jmax(j), kmax(k) {}
  146.         ~Tableau() { delete [] ptr; }
  147.         T& operator () (int i, int j, int k)
  148.         {
  149.             //assert(i>=0 && i<imax && j>=0 && j<jmax && k>=0 && k<=kmax);
  150.             return ptr[(((i+imax)%imax)*jmax+(j+jmax)%jmax)*kmax+(k+kmax)%kmax];
  151.         }
  152.     private:
  153.         int imax, jmax, kmax;
  154.         T *ptr;
  155. };
  156. /*fin de modèle*/
  157.